Algorithms for the Data Placement Problem

We consider the data placement problem introduced by Baev & Rajaraman [1]. We have a set of caches, F , a set of data objects O, and a set of clients D. Each object s ∈ O has a length ls and a cache i ∈ F has capacity ui that limits the total length of data objects that may be stored in the cache. Further, each client j ∈ D has demand dj for a specific data object s(j) ∈ O and has to be assigned to a cache that stores that object. Storing an object s in cache i incurs a storage cost of fs i and assigning client j to cache i incurs an access cost of djls(j)cij proportional to the distance cij between i and j. The data placement problem seeks a placement of the data objects to caches that respects cache capacities and an assignment of clients to caches, so as to minimize the total storage and client access costs. More precisely, for each cache i in F we want to determine the set of objects O(i) ⊆ O it stores such that ∑ s∈O(i) ls ≤ ui and assign each client j to a cache i(j) that stores object s(j), i.e., s(j) ∈ O(i), and we want to minimize ∑ i∈F ∑ s∈O(i) f s i + ∑ j∈D djls(j)ci(j)j . We assume that the caches and clients are located in a common metric space, so the distances cij form a metric. The data placement problem is a generalization of the metric uncapacitated facility location (UFL) problem and is NP-hard even when all object lengths are equal. We give a 10-approximation algorithm for the problem when all objects have the same length, improving upon the approximation guarantee of 20.5 given by Baev & Rajaraman [1]. Our improvement comes from an improved rounding procedure for a natural LP relaxation of the problem also considered in [1]. As in [1], we can modify the algorithm get a bicriteria approximation guarantee when objects have different lengths; the placement returned has cost at most 10 times the optimal, but the total length of objects stored in a cache may exceed the cache capacity by the maximum object length. We also extend the algorithm to the k-median variant, where there is a bound ks imposed, for every object s, on the number of caches that may store object s. As stated in [1], it is not hard to show via a reduction from the PARTITION problem, that with arbitrary object lengths, it is NP-complete to even decide if there is a feasible solution and hence no approximation ratio is achievable in polynomial-time unless P=NP. [1] showed that the problem is MAXSNP-hard even if all objects have the same length and there are no storage costs, by reducing metric UFL to the problem, and gave a 20.5-approximation algorithm. In their model, client j has demand djs for every object s ∈ O and incurs a corresponding access cost; however this easily reduces to our model since for every object s, we can simply create a copy j(s) with demand djs (for object s).